See the Evolution
in Real Code

// ✅ MODEL — UserService handles data fetching logic
// Separate from Activity — reusable, partially testable

interface UserCallback {
    fun onSuccess(user: User)
    fun onError(message: String)
}

class UserService {
    private val retrofit = Retrofit.Builder()
        .baseUrl("https://api.example.com/")
        .addConverterFactory(GsonConverterFactory.create())
        .build()

    private val api = retrofit.create(UserApi::class.java)

    fun getUser(userId: String, callback: UserCallback) {
        api.getUser(userId).enqueue(object : Callback<User> {
            override fun onResponse(call: Call<User>, response: Response<User>) {
                if (response.isSuccessful()) {
                    callback.onSuccess(response.body()!!)
                } else {
                    callback.onError("Server error ${response.code()}")
                }
            }
            override fun onFailure(call: Call<User>, t: Throwable) {
                callback.onError(t.message ?: "Unknown error")
            }
        })
    }
}

// ⚠ CONTROLLER — Owns logic but still references Activity
// ❌ Can't test without Android framework due to Context

class UserController(private val activity: UserProfileActivity) {

    private val userService = UserService()

    fun loadUser(userId: String) {
        // Tell View to show loading
        activity.showLoading()

        userService.getUser(userId, object : UserCallback {
            override fun onSuccess(user: User) {
                // ❌ activity could be destroyed by now!
                activity.showUser(user)
            }
            override fun onError(message: String) {
                activity.showError(message)
            }
        })
    }
}

// ⚠ VIEW — Activity as View. Simpler than God Activity but
// ❌ It creates the Controller itself — tight coupling
// ❌ Controller has direct Activity reference → memory leak risk

class UserProfileActivity : AppCompatActivity() {

    private lateinit var binding:    ActivityUserProfileBinding
    private lateinit var controller: UserController

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding     = ActivityUserProfileBinding.inflate(layoutInflater)
        controller  = UserController(this) // ❌ passes 'this' — tight coupling
        setContentView(binding.root)

        val userId = intent.getStringExtra("USER_ID") ?: return
        controller.loadUser(userId)
    }

    // "View" methods called by Controller
    fun showLoading() {
        binding.progressBar.visibility = View.VISIBLE
        binding.errorText.visibility   = View.GONE
        binding.content.visibility     = View.GONE
    }

    fun showUser(user: User) {
        binding.progressBar.visibility = View.GONE
        binding.content.visibility     = View.VISIBLE
        binding.tvName.text             = user.name
        binding.tvEmail.text            = user.email
        Glide.with(this).load(user.avatarUrl).into(binding.ivAvatar)
    }

    fun showError(message: String) {
        binding.progressBar.visibility = View.GONE
        binding.errorText.visibility   = View.VISIBLE
        binding.errorText.text          = message
    }
}

// ✅ PRESENTER — Pure Kotlin, zero Android imports
// Holds IView reference (not Activity) → unit-testable!

class UserPresenter(
    private val repository: UserRepository
) : UserContract.Presenter {

    // ✅ Interface reference — not the Activity itself
    private var view: UserContract.View? = null

    override fun attachView(view: UserContract.View) { this.view = view }
    override fun detachView()                            { this.view = null  }

    override fun loadUser(userId: String) {
        view?.showLoading()

        repository.getUser(userId, object : UserCallback {
            override fun onSuccess(user: User) {
                // ✅ Safe null check — view is null if Activity was destroyed
                view?.hideLoading()
                view?.showUser(user)
            }
            override fun onError(message: String) {
                view?.hideLoading()
                view?.showError(message)
            }
        })
    }
}

// ✅ MODEL — Repository pattern separates data concerns
// Can be swapped for fake in tests

interface UserRepository {
    fun getUser(userId: String, callback: UserCallback)
}

class UserRepositoryImpl(private val api: UserApi) : UserRepository {

    override fun getUser(userId: String, callback: UserCallback) {
        api.getUser(userId).enqueue(object : Callback<User> {
            override fun onResponse(call: Call<User>, res: Response<User>) {
                if (res.isSuccessful()) callback.onSuccess(res.body()!!)
                else callback.onError("Server error")
            }
            override fun onFailure(call: Call<User>, t: Throwable) {
                callback.onError(t.message ?: "Error")
            }
        })
    }
}

// ✅ VIEW — Activity is now a thin shell
// ⚠ Must remember attachView/detachView — easy to forget!

class UserProfileActivity : AppCompatActivity(), UserContract.View {

    private lateinit var binding:   ActivityUserProfileBinding
    private lateinit var presenter: UserContract.Presenter

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding   = ActivityUserProfileBinding.inflate(layoutInflater)
        presenter = UserPresenter(UserRepositoryImpl(ApiClient.api))
        setContentView(binding.root)

        presenter.attachView(this) // ⚠ Don't forget!
        intent.getStringExtra("USER_ID")?.let { presenter.loadUser(it) }
    }

    override fun onDestroy() {
        presenter.detachView() // ⚠ Don't forget! Memory leak if missed
        super.onDestroy()
    }

    override fun showLoading() {
        binding.progressBar.visibility = View.VISIBLE
        binding.content.visibility     = View.GONE
    }
    override fun hideLoading() { binding.progressBar.visibility = View.GONE }
    override fun showUser(user: User) {
        binding.content.visibility = View.VISIBLE
        binding.tvName.text         = user.name
        binding.tvEmail.text        = user.email
        Glide.with(this).load(user.avatarUrl).into(binding.ivAvatar)
    }
    override fun showError(msg: String) {
        binding.errorText.visibility = View.VISIBLE
        binding.errorText.text        = msg
    }
}

// ✅ UNIT TEST — No Android SDK needed at all!
// This is MVP's biggest win

class UserPresenterTest {

    // Mock the View interface — not the Activity
    private val mockView       = mock(UserContract.View::class.java)
    private val mockRepository = mock(UserRepository::class.java)
    private val presenter      = UserPresenter(mockRepository)

    @Before
    fun setup() { presenter.attachView(mockView) }

    @Test
    fun `loadUser shows loading then user on success`() {
        val fakeUser = User("1", "Alice", "alice@test.com", "http://...")

        // Arrange: repository will call onSuccess
        whenever(mockRepository.getUser(any(), any())).thenAnswer {
            (it.arguments[1] as UserCallback).onSuccess(fakeUser)
        }

        // Act
        presenter.loadUser("1")

        // Assert — verify View methods were called correctly
        verify(mockView).showLoading()
        verify(mockView).hideLoading()
        verify(mockView).showUser(fakeUser)
        verifyNoMoreInteractions(mockView)
    }
}

// ✅ REPOSITORY — Suspend functions, single source of truth
// Combines local DB (Room) + remote API (Retrofit)

interface UserRepository {
    suspend fun getUser(userId: String): Result<User>
}

class UserRepositoryImpl(
    private val api:     UserApi,
    private val userDao: UserDao  // Room DAO
) : UserRepository {

    override suspend fun getUser(userId: String): Result<User> {
        // Try cache first
        userDao.getUser(userId)?.let { return Result.success(it.toDomain()) }

        // Fetch from network
        return runCatching {
            val dto = api.getUser(userId)
            userDao.insertUser(dto.toEntity()) // Cache locally
            dto.toDomain()
        }
    }
}

// ✅ VIEW — Activity is very thin, just observes
// ✅ viewModels() delegate handles ViewModel lifecycle

class UserProfileActivity : AppCompatActivity() {

    private lateinit var binding: ActivityUserProfileBinding

    // ✅ ViewModels survive rotation — no manual save/restore
    private val viewModel: UserViewModel by viewModels {
        UserViewModelFactory(UserRepositoryImpl(ApiClient.api, AppDatabase.dao))
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityUserProfileBinding.inflate(layoutInflater)
        setContentView(binding.root)

        // ✅ Collect lifecycle-safely — auto-stops when Activity is stopped
        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                launch { viewModel.isLoading.collect { setLoading(it) } }
                launch { viewModel.user.collect      { it?.let { u -> showUser(u) } } }
                launch { viewModel.error.collect     { it?.let { e -> showError(e) } } }
            }
        }

        intent.getStringExtra("USER_ID")?.let { viewModel.loadUser(it) }
    }

    private fun setLoading(loading: Boolean) {
        binding.progressBar.visibility = if (loading) View.VISIBLE else View.GONE
    }
    private fun showUser(user: User) {
        binding.tvName.text  = user.name
        binding.tvEmail.text = user.email
        Glide.with(this).load(user.avatarUrl).into(binding.ivAvatar)
    }
    private fun showError(msg: String) { binding.errorText.text = msg }
}

// ✅ COMPOSE VERSION — collectAsState() + MVVM = perfect pair

@Composable
fun UserProfileScreen(
    userId:    String,
    viewModel: UserViewModel = hiltViewModel()
) {
    val isLoading by viewModel.isLoading.collectAsState()
    val user      by viewModel.user.collectAsState()
    val error     by viewModel.error.collectAsState()

    LaunchedEffect(userId) { viewModel.loadUser(userId) }

    Box(modifier = Modifier.fillMaxSize()) {
        when {
            isLoading         -> CircularProgressIndicator(modifier = Modifier.align(Alignment.Center))
            error != null     -> Text(text = error!!, color = Color.Red)
            user  != null     -> UserContent(user = user!!)
        }
    }
}

// ✅ VIEWMODEL TEST — Uses TestCoroutineDispatcher
// No Android framework needed

@ExperimentalCoroutinesApi
class UserViewModelTest {

    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()

    private val fakeRepo = mockk<UserRepository>()
    private val viewModel = UserViewModel(fakeRepo)

    @Test
    fun `loadUser emits user on success`() = runTest {
        val fakeUser = User("1", "Alice", "alice@test.com", "")
        coEvery { fakeRepo.getUser("1") } returns Result.success(fakeUser)

        viewModel.loadUser("1")

        assertEquals(fakeUser, viewModel.user.value)
        assertEquals(false,    viewModel.isLoading.value)
        assertNull(            viewModel.error.value)
    }
}

// ✅ VIEWMODEL with Reducer — processes Intents → emits new State
// ✅ updateState() is atomic — no intermediate inconsistent states

class UserViewModel(private val repository: UserRepository) : ViewModel() {

    // ✅ ONE state object — impossible states are impossible
    private val _uiState = MutableStateFlow(UserUiState())
    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()

    // ✅ Channel — effects consumed exactly once, no re-delivery on rotation
    private val _effect = Channel<UserEffect>(Channel.BUFFERED)
    val effect: Flow<UserEffect> = _effect.receiveAsFlow()

    // ✅ Single entry point for all user actions
    fun handleIntent(intent: UserIntent) {
        when (intent) {
            is UserIntent.LoadUser  -> loadUser(intent.userId)
            is UserIntent.RetryLoad  -> _uiState.value.user?.id?.let { loadUser(it) }
            is UserIntent.DismissError -> updateState { copy(error = null) }
        }
    }

    private fun loadUser(userId: String) {
        viewModelScope.launch {
            // ✅ Single atomic update — all fields change together
            updateState { copy(isLoading = true, error = null, user = null) }

            repository.getUser(userId)
                .onSuccess { user ->
                    updateState { copy(isLoading = false, user = user) }
                    _effect.send(UserEffect.ShowToast("Welcome, ${user.name}!"))
                }
                .onFailure { t ->
                    updateState { copy(isLoading = false, error = t.message) }
                }
        }
    }

    // ✅ Helper — atomic state update, thread-safe
    private fun updateState(reduce: UserUiState.() -> UserUiState) {
        _uiState.update { it.reduce() }
    }
}

// ✅ COMPOSE + MVI — single state drives the entire UI
// collectAsState() + when(uiState) = perfectly predictable

@Composable
fun UserProfileScreen(
    userId:    String,
    viewModel: UserViewModel = hiltViewModel()
) {
    val uiState by viewModel.uiState.collectAsState()
    val context = LocalContext.current

    // ✅ Effect consumed once — no re-delivery on recompose/rotation
    LaunchedEffect(Unit) {
        viewModel.effect.collect { effect ->
            when (effect) {
                is UserEffect.ShowToast   -> Toast.makeText(context, effect.message, Toast.LENGTH_SHORT).show()
                is UserEffect.NavigateBack -> { /* navigate */ }
            }
        }
    }

    LaunchedEffect(userId) {
        viewModel.handleIntent(UserIntent.LoadUser(userId))
    }

    // ✅ Renders based on SINGLE state — always consistent
    Box(modifier = Modifier.fillMaxSize()) {
        when {
            uiState.isLoading            -> LoadingView()
            uiState.error != null        -> ErrorView(
                message = uiState.error!!,
                onRetry = { viewModel.handleIntent(UserIntent.RetryLoad) }
            )
            uiState.user != null         -> UserContent(user = uiState.user!!)
            else                          -> EmptyView()
        }
    }
}

// ✅ PUREST TESTS — State-in → State-out, no mocks needed for assertions
// Just check: "given state X + intent Y → state Z"

class UserViewModelTest {

    @get:Rule val dispatcher = MainDispatcherRule()

    private val fakeRepo   = mockk<UserRepository>()
    private val viewModel  = UserViewModel(fakeRepo)

    @Test
    fun `LoadUser intent transitions to loading then success state`() = runTest {
        val fakeUser = User("1", "Alice", "alice@test.com", "")
        coEvery { fakeRepo.getUser("1") } returns Result.success(fakeUser)

        viewModel.handleIntent(UserIntent.LoadUser("1"))

        // Assert final state — single object, easy to read
        assertEquals(
            UserUiState(isLoading = false, user = fakeUser, error = null),
            viewModel.uiState.value
        )
    }

    @Test
    fun `DismissError intent clears error from state`() = runTest {
        // Seed state with an error
        coEvery { fakeRepo.getUser(any()) } throws Exception("Network error")
        viewModel.handleIntent(UserIntent.LoadUser("1"))
        assertNotNull(viewModel.uiState.value.error)

        // Dismiss — error should be gone
        viewModel.handleIntent(UserIntent.DismissError)
        assertNull(viewModel.uiState.value.error)
    }
}

// ✅ USE CASE — :domain module, pure Kotlin, single responsibility
// THIS is where business logic lives — not in ViewModel, not in Repository
// "A user can only be loaded if the current session is valid"
// "Premium status is derived from subscription expiry date"

class GetUserUseCase(
    private val userRepository:    UserRepository,     // Domain interface
    private val sessionRepository:  SessionRepository  // Domain interface
) {
    // ✅ suspend operator fun — call as: getUser("123")
    suspend operator fun invoke(userId: String): DomainResult<User> {

        // Business rule 1: Must be authenticated
        if (!sessionRepository.isAuthenticated()) {
            return DomainResult.Error(DomainException.Unauthorized)
        }

        return userRepository.getUser(userId).fold(
            onSuccess = { userDto ->
                // Business rule 2: Premium derived from subscription end date
                val isPremium = userDto.subscriptionEndDate?.isAfterNow() ?: false
                DomainResult.Success(
                    User(
                        id        = userDto.id,
                        name      = userDto.name,
                        email     = userDto.email,
                        avatarUrl = userDto.avatarUrl,
                        isPremium = isPremium  // ← Business logic in Domain, not ViewModel
                    )
                )
            },
            onFailure = { t ->
                DomainResult.Error(DomainException.NetworkError(t.message ?: "Error"))
            }
        )
    }
}

// ✅ REPOSITORY INTERFACE — :domain module
// Domain DEFINES the interface. Data layer IMPLEMENTS it.
// Dependency Inversion Principle — the crown jewel of Clean Architecture
// Swap SQLite for Firestore? Only :data module changes. Domain is untouched.

interface UserRepository {
    suspend fun getUser(userId: String): Result<UserDto>
    suspend fun saveUser(user: User): Result<Unit>
}

interface SessionRepository {
    suspend fun isAuthenticated(): Boolean
    suspend fun getCurrentUserId(): String?
}

// DTO lives at the boundary between Domain and Data
data class UserDto(
    val id:                  String,
    val name:                String,
    val email:               String,
    val avatarUrl:           String,
    val subscriptionEndDate: String? // Raw from API — Domain interprets this
)

// ✅ REPOSITORY IMPLEMENTATION — :data module
// Knows about Room, Retrofit. Domain knows NOTHING about these.

class UserRepositoryImpl(
    private val api:     UserApi,
    private val userDao: UserDao
) : UserRepository {           // ← Implements Domain interface

    override suspend fun getUser(userId: String): Result<UserDto> {
        // 1. Try Room cache first
        userDao.getUser(userId)?.let {
            return Result.success(it.toDto())  // Entity → DTO mapper
        }

        // 2. Fetch from Retrofit
        return runCatching {
            val response = api.getUser(userId)  // UserApiResponse (API model)
            userDao.insertUser(response.toEntity()) // ApiResponse → Room Entity
            response.toDto()                       // ApiResponse → DTO
        }
    }

    override suspend fun saveUser(user: User): Result<Unit> =
        runCatching { userDao.insertUser(user.toEntity()) }
}

// ✅ Mappers keep each layer's model clean
fun UserEntity.toDto()     = UserDto(id, name, email, avatarUrl, subscriptionEndDate)
fun UserApiResponse.toDto() = UserDto(id, name, email, avatarUrl, subscriptionEndDate)
fun UserApiResponse.toEntity() = UserEntity(id, name, email, avatarUrl, subscriptionEndDate)

// ✅ VIEWMODEL — :ui module, uses Use Case (not Repository directly!)
// ViewModel is THIN — just orchestrates Use Case calls and maps results to UiState
// Notice: no business logic here. "isPremium" logic is in the Use Case.

@HiltViewModel
class UserViewModel @Inject constructor(
    private val getUserUseCase: GetUserUseCase  // ← Use Case, not Repository
) : ViewModel() {

    private val _uiState = MutableStateFlow(UserUiState())
    val uiState = _uiState.asStateFlow()

    private val _effect = Channel<UserEffect>(Channel.BUFFERED)
    val effect = _effect.receiveAsFlow()

    fun handleIntent(intent: UserIntent) {
        when (intent) {
            is UserIntent.LoadUser   -> loadUser(intent.userId)
            is UserIntent.RetryLoad  -> _uiState.value.user?.id?.let { loadUser(it) }
            is UserIntent.DismissError -> updateState { copy(error = null) }
        }
    }

    private fun loadUser(userId: String) {
        viewModelScope.launch {
            updateState { copy(isLoading = true, error = null) }

            // ✅ Use Case called — business rules run inside, ViewModel stays thin
            when (val result = getUserUseCase(userId)) {
                is DomainResult.Success -> {
                    updateState { copy(isLoading = false, user = result.data) }
                    if (result.data.isPremium) {
                        _effect.send(UserEffect.ShowToast("✦ Premium member!"))
                    }
                }
                is DomainResult.Error -> {
                    val msg = when (result.exception) {
                        is DomainException.Unauthorized  -> "Please log in again"
                        is DomainException.UserNotFound  -> "User not found"
                        is DomainException.NetworkError  -> result.exception.message ?: "Network error"
                    }
                    updateState { copy(isLoading = false, error = msg) }
                }
            }
        }
    }

    private fun updateState(reduce: UserUiState.() -> UserUiState) = _uiState.update { it.reduce() }
}

// ✅ DEPENDENCY INJECTION — Hilt wires everything together
// The entire dependency graph is defined here — not scattered across classes

@Module
@InstallIn(SingletonComponent::class)
object UserModule {

    @Provides @Singleton
    fun provideUserApi(retrofit: Retrofit): UserApi =
        retrofit.create(UserApi::class.java)

    @Provides @Singleton
    fun provideUserRepository(   // ← Returns Domain interface type
        api: UserApi, dao: UserDao
    ): UserRepository = UserRepositoryImpl(api, dao)

    @Provides
    fun provideGetUserUseCase(
        userRepo:    UserRepository,
        sessionRepo: SessionRepository
    ): GetUserUseCase = GetUserUseCase(userRepo, sessionRepo)
}

// ✅ USE CASE TESTS — Pure Kotlin, no Android, no Compose, no Room
// Tests are deterministic: inject fake repos → assert business logic
// This is the cleanest, fastest test suite in the entire codebase

class GetUserUseCaseTest {

    private val userRepo    = mockk<UserRepository>()
    private val sessionRepo = mockk<SessionRepository>()
    private val useCase     = GetUserUseCase(userRepo, sessionRepo)

    @Test
    fun `returns Unauthorized when not authenticated`() = runTest {
        coEvery { sessionRepo.isAuthenticated() } returns false

        val result = useCase("1")

        assertIs<DomainResult.Error>(result)
        assertIs<DomainException.Unauthorized>(result.exception)
    }

    @Test
    fun `marks user as premium when subscription is active`() = runTest {
        coEvery { sessionRepo.isAuthenticated() } returns true
        coEvery { userRepo.getUser("1") } returns Result.success(
            UserDto("1", "Alice", "alice@test.com", "", subscriptionEndDate = "2099-01-01")
        )

        val result = useCase("1")

        assertIs<DomainResult.Success<User>>(result)
        assertTrue(result.data.isPremium)  // ← Business rule tested in isolation
    }

    @Test
    fun `marks user as NOT premium when subscription expired`() = runTest {
        coEvery { sessionRepo.isAuthenticated() } returns true
        coEvery { userRepo.getUser("1") } returns Result.success(
            UserDto("1", "Bob", "bob@test.com", "", subscriptionEndDate = "2020-01-01")
        )

        val result = useCase("1")

        assertIs<DomainResult.Success<User>>(result)
        assertFalse(result.data.isPremium)
    }
}